This function could eventually disappear, and is only a starting point for using Version - also see #871.

Use ctype_digit() ?

ctype_digit($value) returns true when $value has a leading 0: https://3v4l.org/XqGiU.

Do we really need those if we have readonly properties?

Depends on whether we want to stick with the internal implementation: using accessors instead of public properties has the advantage that we can change the internals any time without changing the consumers.

I can adjust, though.

We could just throw a ValueError

Why not $version = Version::fromString($value); What am I missing?

Adjusted!

I have written about Avoiding imports and aliases in PHP; I generally try to avoid importing every single class from a specific namespace.

Thanks. I am rather against importing the namespace. IMHO every class should be imported unless it conflicts with another one. Only in case of conflicts, one should import namespace. Importing the full name makes for a cleaner code. The line is shorter, there's less visual bloat and my eyes can focus on what's really important: the name of the class. For the most part, I am not interested from which namespace the class comes. I can always hover over it to see the full namespace. The import list is maintained automatically by IDEs so I never look at it. If the import list is too long, it can always be collapsed using the alternative syntax.

This method is completely unnecessary and also can be easily confused with the magic method __toString. This is the same as making the property public and directly accessing it.

It's a matter of preference - when I allow constructing an object from a simple type, I typically use a named constructor fromSimpleType() and a corresponding method toSimpleType(). This allows to construct an object from and cast it to other simple types when necessary, and hides the internals.

I have written about Naming constructors in PHP, where I attempt to explain my reasoning.

Also see https://github.com/php/web-php/pull/872/files#r1418528779.

Why not just use the magic method __toString?

I prefer to explicitly invoke a method to cast a type to another type instead of relying on a magic method.

Why not just make the constructor public?

Using one or more public named constructors and a single private constructor in conjunction with accessors instead of public properties allows us to change the internals of the class as needed.

From the call-site it does not matter whether someone invokes a method or accesses a property, but relying on a public property makes it harder to change internals.

For example, we could change the internals as follows and would not need to make any changes to call-sites:

diff --git a/src/Release/Version.php b/src/Release/Version.php
index 47975096..6b5664fd 100644
--- a/src/Release/Version.php
+++ b/src/Release/Version.php
@@ -6,11 +6,9 @@ namespace phpweb\Release;

 final readonly class Version
 {
-    private function __construct(
-        private Major $major,
-        private Minor $minor,
-        private Patch $patch,
-    ) {
+    private function __construct(private string $value)
+    {
+
     }

     public static function create(
@@ -18,11 +16,12 @@ final readonly class Version
         Minor $minor,
         Patch $patch,
     ): self {
-        return new self(
-            $major,
-            $minor,
-            $patch,
-        );
+        return new self(sprintf(
+            '%s.%s.%s',
+            $major->toString(),
+            $minor->toString(),
+            $patch->toString(),
+        ));
     }

     /**
@@ -37,35 +36,32 @@ final readonly class Version
             ));
         }

-        return new self(
-            Major::fromString($matches['major']),
-            Minor::fromString($matches['minor']),
-            Patch::fromString($matches['patch']),
-        );
+        return new self($value);
     }

     public function major(): Major
     {
-        return $this->major;
+        $parts = explode('.', $this->value);
+
+        return Major::fromString($parts[0]);
     }

     public function minor(): Minor
     {
-        return $this->minor;
+        $parts = explode('.', $this->value);
+
+        return Minor::fromString($parts[1]);
     }

     public function patch(): Patch
     {
-        return $this->patch;
+        $parts = explode('.', $this->value);
+
+        return Patch::fromString($parts[2]);
     }

     public function toString(): string
     {
-        return sprintf(
-            '%s.%s.%s',
-            $this->major->toString(),
-            $this->minor->toString(),
-            $this->patch->toString(),
-        );
+        return $this->value;
     }
 }

Personally, I prefer the principles of KISS and YAGNI. When it comes to value objects, they should remain as simple as possible. But there's no reason to spend too much time on this as it feels more of a stylistic choice than anything else.

This is too complex. Please simplify it to get rid of the higher-order function.

This is a basic array_filter() usage, I don't see how this is complex.

Could it be just a foreach loop? Sure, but that just a preference at this point.

@Girgias @kamil-tekiela

Do you have any suggestions how to work with data providers in phpt tests?

This is what I am trying to achieve here.

@Girgias Isn't this easier to read?

@kamil-tekiela @Girgias

I can adjust if you prefer!